"""
__rule_example_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Thu Jan 31 11:54:56 2013
__________________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Station_S import *
from Male_S import *
from Female_S import *
from MatchModel import *
from ApplyModel import *
from Station_T import *
from Male_T import *
from Female_T import *
from match_contains import *
from apply_contains import *
from indirectLink_S import *
from directLink_T import *
from directLink_S import *
from graph_ApplyModel import *
from graph_directLink_T import *
from graph_directLink_S import *
from graph_MatchModel import *
from graph_apply_contains import *
from graph_Station_T import *
from graph_Station_S import *
from graph_match_contains import *
from graph_Male_T import *
from graph_Female_S import *
from graph_Female_T import *
from graph_Male_S import *
from graph_indirectLink_S import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def rule_example_MDL(self, rootNode, SimpleDSLTransMMRootNode=None):

    # --- Generating attributes code for ASG SimpleDSLTransMM ---
    if( SimpleDSLTransMMRootNode ): 
        # author
        SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        SimpleDSLTransMMRootNode.description.setValue('\n')
        SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        SimpleDSLTransMMRootNode.name.setValue('RuleExample')
    # --- ASG attributes over ---


    self.obj32=Station_S(self)
    self.obj32.isGraphObjectVisual = True

    if(hasattr(self.obj32, '_setHierarchicalLink')):
      self.obj32._setHierarchicalLink(False)

    # classtype
    self.obj32.classtype.setValue('station')

    # name
    self.obj32.name.setValue('sm1')

    self.obj32.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(540.0,140.0,self.obj32)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj32.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj32)
    self.globalAndLocalPostcondition(self.obj32, rootNode)
    self.obj32.postAction( rootNode.CREATE )

    self.obj34=Station_S(self)
    self.obj34.isGraphObjectVisual = True

    if(hasattr(self.obj34, '_setHierarchicalLink')):
      self.obj34._setHierarchicalLink(False)

    # classtype
    self.obj34.classtype.setValue('station')

    # name
    self.obj34.name.setValue('sm2')

    self.obj34.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(540.0,300.0,self.obj34)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj34.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj34)
    self.globalAndLocalPostcondition(self.obj34, rootNode)
    self.obj34.postAction( rootNode.CREATE )

    self.obj33=Male_S(self)
    self.obj33.isGraphObjectVisual = True

    if(hasattr(self.obj33, '_setHierarchicalLink')):
      self.obj33._setHierarchicalLink(False)

    # classtype
    self.obj33.classtype.setValue('male')

    # name
    self.obj33.name.setValue('mm1')

    self.obj33.graphClass_= graph_Male_S
    if self.genGraphics:
       new_obj = graph_Male_S(780.0,140.0,self.obj33)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj33.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj33)
    self.globalAndLocalPostcondition(self.obj33, rootNode)
    self.obj33.postAction( rootNode.CREATE )

    self.obj35=Female_S(self)
    self.obj35.isGraphObjectVisual = True

    if(hasattr(self.obj35, '_setHierarchicalLink')):
      self.obj35._setHierarchicalLink(False)

    # classtype
    self.obj35.classtype.setValue('female')

    # name
    self.obj35.name.setValue('fm1')

    self.obj35.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(780.0,300.0,self.obj35)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj35.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj35)
    self.globalAndLocalPostcondition(self.obj35, rootNode)
    self.obj35.postAction( rootNode.CREATE )

    self.obj30=MatchModel(self)
    self.obj30.isGraphObjectVisual = True

    if(hasattr(self.obj30, '_setHierarchicalLink')):
      self.obj30._setHierarchicalLink(False)

    self.obj30.graphClass_= graph_MatchModel
    if self.genGraphics:
       new_obj = graph_MatchModel(242.0,219.0,self.obj30)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj30.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj30)
    self.globalAndLocalPostcondition(self.obj30, rootNode)
    self.obj30.postAction( rootNode.CREATE )

    self.obj31=ApplyModel(self)
    self.obj31.isGraphObjectVisual = True

    if(hasattr(self.obj31, '_setHierarchicalLink')):
      self.obj31._setHierarchicalLink(False)

    self.obj31.graphClass_= graph_ApplyModel
    if self.genGraphics:
       new_obj = graph_ApplyModel(242.0,539.0,self.obj31)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj31.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj31)
    self.globalAndLocalPostcondition(self.obj31, rootNode)
    self.obj31.postAction( rootNode.CREATE )

    self.obj36=Station_T(self)
    self.obj36.isGraphObjectVisual = True

    if(hasattr(self.obj36, '_setHierarchicalLink')):
      self.obj36._setHierarchicalLink(False)

    # classtype
    self.obj36.classtype.setValue('station')

    # name
    self.obj36.name.setValue('sa1')

    self.obj36.graphClass_= graph_Station_T
    if self.genGraphics:
       new_obj = graph_Station_T(540.0,460.0,self.obj36)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj36.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj36)
    self.globalAndLocalPostcondition(self.obj36, rootNode)
    self.obj36.postAction( rootNode.CREATE )

    self.obj37=Station_T(self)
    self.obj37.isGraphObjectVisual = True

    if(hasattr(self.obj37, '_setHierarchicalLink')):
      self.obj37._setHierarchicalLink(False)

    # classtype
    self.obj37.classtype.setValue('station')

    # name
    self.obj37.name.setValue('sa2')

    self.obj37.graphClass_= graph_Station_T
    if self.genGraphics:
       new_obj = graph_Station_T(540.0,640.0,self.obj37)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj37.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj37)
    self.globalAndLocalPostcondition(self.obj37, rootNode)
    self.obj37.postAction( rootNode.CREATE )

    self.obj38=Male_T(self)
    self.obj38.isGraphObjectVisual = True

    if(hasattr(self.obj38, '_setHierarchicalLink')):
      self.obj38._setHierarchicalLink(False)

    # classtype
    self.obj38.classtype.setValue('male')

    # name
    self.obj38.name.setValue('ma1')

    self.obj38.graphClass_= graph_Male_T
    if self.genGraphics:
       new_obj = graph_Male_T(780.0,460.0,self.obj38)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj38.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj38)
    self.globalAndLocalPostcondition(self.obj38, rootNode)
    self.obj38.postAction( rootNode.CREATE )

    self.obj39=Female_T(self)
    self.obj39.isGraphObjectVisual = True

    if(hasattr(self.obj39, '_setHierarchicalLink')):
      self.obj39._setHierarchicalLink(False)

    # classtype
    self.obj39.classtype.setValue('female')

    # name
    self.obj39.name.setValue('fa1')

    self.obj39.graphClass_= graph_Female_T
    if self.genGraphics:
       new_obj = graph_Female_T(780.0,640.0,self.obj39)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj39.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj39)
    self.globalAndLocalPostcondition(self.obj39, rootNode)
    self.obj39.postAction( rootNode.CREATE )

    self.obj64=match_contains(self)
    self.obj64.isGraphObjectVisual = True

    if(hasattr(self.obj64, '_setHierarchicalLink')):
      self.obj64._setHierarchicalLink(False)

    self.obj64.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(452.0,220.5,self.obj64)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj64.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj64)
    self.globalAndLocalPostcondition(self.obj64, rootNode)
    self.obj64.postAction( rootNode.CREATE )

    self.obj65=match_contains(self)
    self.obj65.isGraphObjectVisual = True

    if(hasattr(self.obj65, '_setHierarchicalLink')):
      self.obj65._setHierarchicalLink(False)

    self.obj65.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(572.0,220.5,self.obj65)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj65.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj65)
    self.globalAndLocalPostcondition(self.obj65, rootNode)
    self.obj65.postAction( rootNode.CREATE )

    self.obj66=match_contains(self)
    self.obj66.isGraphObjectVisual = True

    if(hasattr(self.obj66, '_setHierarchicalLink')):
      self.obj66._setHierarchicalLink(False)

    self.obj66.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(452.0,300.5,self.obj66)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj66.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj66)
    self.globalAndLocalPostcondition(self.obj66, rootNode)
    self.obj66.postAction( rootNode.CREATE )

    self.obj67=match_contains(self)
    self.obj67.isGraphObjectVisual = True

    if(hasattr(self.obj67, '_setHierarchicalLink')):
      self.obj67._setHierarchicalLink(False)

    self.obj67.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(572.0,300.5,self.obj67)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj67.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj67)
    self.globalAndLocalPostcondition(self.obj67, rootNode)
    self.obj67.postAction( rootNode.CREATE )

    self.obj68=apply_contains(self)
    self.obj68.isGraphObjectVisual = True

    if(hasattr(self.obj68, '_setHierarchicalLink')):
      self.obj68._setHierarchicalLink(False)

    self.obj68.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(454.5,540.5,self.obj68)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj68.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj68)
    self.globalAndLocalPostcondition(self.obj68, rootNode)
    self.obj68.postAction( rootNode.CREATE )

    self.obj69=apply_contains(self)
    self.obj69.isGraphObjectVisual = True

    if(hasattr(self.obj69, '_setHierarchicalLink')):
      self.obj69._setHierarchicalLink(False)

    self.obj69.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(574.5,540.5,self.obj69)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj69.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj69)
    self.globalAndLocalPostcondition(self.obj69, rootNode)
    self.obj69.postAction( rootNode.CREATE )

    self.obj70=apply_contains(self)
    self.obj70.isGraphObjectVisual = True

    if(hasattr(self.obj70, '_setHierarchicalLink')):
      self.obj70._setHierarchicalLink(False)

    self.obj70.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(454.5,630.5,self.obj70)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj70.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj70)
    self.globalAndLocalPostcondition(self.obj70, rootNode)
    self.obj70.postAction( rootNode.CREATE )

    self.obj71=apply_contains(self)
    self.obj71.isGraphObjectVisual = True

    if(hasattr(self.obj71, '_setHierarchicalLink')):
      self.obj71._setHierarchicalLink(False)

    self.obj71.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(574.5,630.5,self.obj71)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj71.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj71)
    self.globalAndLocalPostcondition(self.obj71, rootNode)
    self.obj71.postAction( rootNode.CREATE )

    self.obj60=indirectLink_S(self)
    self.obj60.isGraphObjectVisual = True

    if(hasattr(self.obj60, '_setHierarchicalLink')):
      self.obj60._setHierarchicalLink(False)

    self.obj60.graphClass_= graph_indirectLink_S
    if self.genGraphics:
       new_obj = graph_indirectLink_S(721.0,181.0,self.obj60)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("indirectLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj60.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj60)
    self.globalAndLocalPostcondition(self.obj60, rootNode)
    self.obj60.postAction( rootNode.CREATE )

    self.obj62=directLink_T(self)
    self.obj62.isGraphObjectVisual = True

    if(hasattr(self.obj62, '_setHierarchicalLink')):
      self.obj62._setHierarchicalLink(False)

    # associationType
    self.obj62.associationType.setValue('t_')

    self.obj62.graphClass_= graph_directLink_T
    if self.genGraphics:
       new_obj = graph_directLink_T(721.0,501.0,self.obj62)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj62.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj62)
    self.globalAndLocalPostcondition(self.obj62, rootNode)
    self.obj62.postAction( rootNode.CREATE )

    self.obj63=directLink_T(self)
    self.obj63.isGraphObjectVisual = True

    if(hasattr(self.obj63, '_setHierarchicalLink')):
      self.obj63._setHierarchicalLink(False)

    # associationType
    self.obj63.associationType.setValue('t_')

    self.obj63.graphClass_= graph_directLink_T
    if self.genGraphics:
       new_obj = graph_directLink_T(721.0,681.0,self.obj63)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj63.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj63)
    self.globalAndLocalPostcondition(self.obj63, rootNode)
    self.obj63.postAction( rootNode.CREATE )

    self.obj61=directLink_S(self)
    self.obj61.isGraphObjectVisual = True

    if(hasattr(self.obj61, '_setHierarchicalLink')):
      self.obj61._setHierarchicalLink(False)

    # associationType
    self.obj61.associationType.setValue('t_')

    self.obj61.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(721.0,341.0,self.obj61)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj61.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj61)
    self.globalAndLocalPostcondition(self.obj61, rootNode)
    self.obj61.postAction( rootNode.CREATE )

    # Connections for obj32 (graphObject_: Obj2) named sm1
    self.drawConnections(
(self.obj32,self.obj60,[601.0, 181.0, 721.0, 181.0],"true", 2) )
    # Connections for obj34 (graphObject_: Obj4) named sm2
    self.drawConnections(
(self.obj34,self.obj61,[601.0, 341.0, 721.0, 341.0],"true", 2) )
    # Connections for obj33 (graphObject_: Obj3) named mm1
    self.drawConnections(
 )
    # Connections for obj35 (graphObject_: Obj5) named fm1
    self.drawConnections(
 )
    # Connections for obj30 (graphObject_: Obj0) of type MatchModel
    self.drawConnections(
(self.obj30,self.obj64,[303.0, 260.0, 452.0, 220.5],"true", 2),
(self.obj30,self.obj65,[303.0, 260.0, 572.0, 220.5],"true", 2),
(self.obj30,self.obj66,[303.0, 260.0, 452.0, 300.5],"true", 2),
(self.obj30,self.obj67,[303.0, 260.0, 572.0, 300.5],"true", 2) )
    # Connections for obj31 (graphObject_: Obj1) of type ApplyModel
    self.drawConnections(
(self.obj31,self.obj68,[308.0, 580.0, 454.5, 540.5],"true", 2),
(self.obj31,self.obj69,[308.0, 580.0, 574.5, 540.5],"true", 2),
(self.obj31,self.obj70,[308.0, 580.0, 454.5, 630.5],"true", 2),
(self.obj31,self.obj71,[308.0, 580.0, 574.5, 630.5],"true", 2) )
    # Connections for obj36 (graphObject_: Obj6) named sa1
    self.drawConnections(
(self.obj36,self.obj62,[601.0, 501.0, 721.0, 501.0],"true", 2) )
    # Connections for obj37 (graphObject_: Obj7) named sa2
    self.drawConnections(
(self.obj37,self.obj63,[601.0, 681.0, 721.0, 681.0],"true", 2) )
    # Connections for obj38 (graphObject_: Obj8) named ma1
    self.drawConnections(
 )
    # Connections for obj39 (graphObject_: Obj9) named fa1
    self.drawConnections(
 )
    # Connections for obj64 (graphObject_: Obj14) of type match_contains
    self.drawConnections(
(self.obj64,self.obj32,[452.0, 220.5, 601.0, 181.0],"true", 2) )
    # Connections for obj65 (graphObject_: Obj15) of type match_contains
    self.drawConnections(
(self.obj65,self.obj33,[572.0, 220.5, 841.0, 181.0],"true", 2) )
    # Connections for obj66 (graphObject_: Obj16) of type match_contains
    self.drawConnections(
(self.obj66,self.obj34,[452.0, 300.5, 601.0, 341.0],"true", 2) )
    # Connections for obj67 (graphObject_: Obj17) of type match_contains
    self.drawConnections(
(self.obj67,self.obj35,[572.0, 300.5, 841.0, 341.0],"true", 2) )
    # Connections for obj68 (graphObject_: Obj18) of type apply_contains
    self.drawConnections(
(self.obj68,self.obj36,[454.5, 540.5, 601.0, 501.0],"true", 2) )
    # Connections for obj69 (graphObject_: Obj19) of type apply_contains
    self.drawConnections(
(self.obj69,self.obj38,[574.5, 540.5, 841.0, 501.0],"true", 2) )
    # Connections for obj70 (graphObject_: Obj20) of type apply_contains
    self.drawConnections(
(self.obj70,self.obj37,[454.5, 630.5, 601.0, 681.0],"true", 2) )
    # Connections for obj71 (graphObject_: Obj21) of type apply_contains
    self.drawConnections(
(self.obj71,self.obj39,[574.5, 630.5, 841.0, 681.0],"true", 2) )
    # Connections for obj60 (graphObject_: Obj10) of type indirectLink_S
    self.drawConnections(
(self.obj60,self.obj33,[721.0, 181.0, 841.0, 181.0],"true", 2) )
    # Connections for obj62 (graphObject_: Obj12) of type directLink_T
    self.drawConnections(
(self.obj62,self.obj38,[721.0, 501.0, 841.0, 501.0],"true", 2) )
    # Connections for obj63 (graphObject_: Obj13) of type directLink_T
    self.drawConnections(
(self.obj63,self.obj39,[721.0, 681.0, 841.0, 681.0],"true", 2) )
    # Connections for obj61 (graphObject_: Obj11) of type directLink_S
    self.drawConnections(
(self.obj61,self.obj35,[721.0, 341.0, 841.0, 341.0],"true", 2) )

newfunction = rule_example_MDL

loadedMMName = 'SimpleDSLTransMM_META'

atom3version = '0.3'
